package com.heo.web.util;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateFormatUtils;


/**
 * 处理String、Date、Array
 * 
 * @author my
 * 
 * @date 2014-5-8
 */
public class Utils {

	public Utils() {

	}

	/**
	 * 字符串转换为double类型 四舍五入
	 * 
	 * @param str
	 *            字符串
	 * 
	 * @param scale
	 *            精度
	 * 
	 * @return double
	 */
	public static double stringToDouble(String str, int scale) {
		double d = 0;
		if (checkNull(str)) {
			BigDecimal l = new BigDecimal(str);
			d = l.setScale(scale, BigDecimal.ROUND_HALF_UP).doubleValue();
		}
		return d;
	}

	/**
	 * 把byte数组转换为字符串
	 * 
	 * @param bytes
	 *            byte数组
	 * 
	 * @return string
	 */
	public static String bytesToString(byte[] bytes) {
		String strBytes = null;
		if (null != bytes && bytes.length > 0) {
			strBytes = new String(bytes);
		}
		return strBytes;
	}

	// 字符串类型的工具方法

	/**
	 * 判断字符串是否有内容 null安全
	 * 
	 * @param str
	 * 
	 * @return
	 */
	public static boolean isEmpty(String str) {
		return StringUtils.isEmpty(str);
	}

	/**
	 * 清除字符串前后空格 null安全
	 * 
	 * @param str
	 * @return
	 */
	public static String trim(String str) {
		return StringUtils.trim(str);
	}

	/**
	 * 替换字符串所有空格、换行符、回车、制表符等
	 * 
	 * @param str
	 * @return
	 */
	public static String replaceBlank(String str) {
		String dest = "";
		if (Utils.checkNull(str)) {
			Pattern p = Pattern.compile("\\s*|t|r|n");
			Matcher m = p.matcher(str);
			dest = m.replaceAll("");
		}
		return dest;
	}

	/**
	 * 截取字符串 null安全
	 * 
	 * @param str
	 * 
	 * @param start
	 *            >=0
	 * @param end
	 * @return
	 */
	public static String substring(String str, int start, int end) {
		return StringUtils.substring(str, start, end);
	}

	/**
	 * 删除某个字符串里的特定内容 null安全
	 * 
	 * @param str
	 * 
	 * @param str2
	 *            需要删除的字符串
	 * @return
	 */
	public static String remove(String str, String str2) {
		return StringUtils.remove(str, str2);
	}

	/**
	 * 替换一个字符串中的内容 null安全 把str中的所有str2替换为str3
	 * 
	 * @param str
	 * @param str2
	 * @param str3
	 * @return
	 */
	public static String replace(String str, String str2, String str3) {
		return StringUtils.replace(str, str2, str3);
	}

	/**
	 * 替换一个字符串中的内容 null安全 把str中的第一个str2替换为str3
	 * 
	 * @param str
	 * @param str2
	 * @param str3
	 * @return
	 */
	public static String replaceOnce(String str, String str2, String str3) {
		return StringUtils.replaceOnce(str, str2, str3);
	}

	/**
	 * 替换一个字符串中的内容 null安全 一次替换多个，按str2数组顺序替换为str3数组里的字符串
	 * 
	 * @param str
	 * @param str2
	 * @param str3
	 * @return
	 */
	public static String replaceEach(String str, String[] str2, String[] str3) {
		return StringUtils.replaceEach(str, str2, str3);
	}

	/**
	 * 简略字符串 例："This is a test" to "This is..."
	 * 
	 * @param str
	 *            需要简略的字符串
	 * @param length
	 *            简略至多少长度 注意：此参数必须>=4
	 * @return
	 */
	public static String abbreviate(String str, int length) {
		return StringUtils.abbreviate(str, length);
	}

	/**
	 * 分隔字符串，使之成为数组
	 * 
	 * @param str
	 *            需要分隔的字符串
	 * @param splitStr
	 *            分隔符
	 * @return
	 */
	public static String[] split(String str, String splitStr) {
		return StringUtils.split(str, splitStr);
	}

	/**
	 * 分隔数组，使之成为以传入字符分隔的字符串
	 * 
	 * @param array
	 *            需要分隔的数组
	 * @param splitStr
	 *            分隔符
	 * @return
	 */
	public static String join(Object[] array, String splitStr) {
		return StringUtils.join(array, splitStr);
	}

	/**
	 * 分隔集合类型，使之成为以传入字符分隔的字符串
	 * 
	 * @param collection
	 * @param splitStr
	 * @return
	 */
	public static String join(Collection<Object> collection, String splitStr) {
		return StringUtils.join(collection, splitStr);
	}

	/**
	 * 查找特定字符串内的内容 例："《 This is a Test 》" to "This is a Test"
	 * 
	 * @param str
	 *            被查找字符串
	 * @param str2
	 *            开始字符串
	 * @param str3
	 *            结束字符串
	 * @return 开始字符第一次出现的位置到结束字符第一次出现的位置之间的内容
	 */
	public static String substringBetween(String str, String str2, String str3) {
		return StringUtils.substringBetween(str, str2, str3);
	}

	/**
	 * 反转字符串 例："ABCD" to "DCBA"
	 * 
	 * @param str
	 * @return
	 */
	public static String reverse(String str) {
		return StringUtils.reverse(str);
	}

	/**
	 * 判断字符串是否只包含字符 A~Z、a~z
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isAlpha(String str) {
		return StringUtils.isAlpha(str);
	}

	/**
	 * 判断字符串是否只包含数字 0~9
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isNumeric(String str) {
		return StringUtils.isNumeric(str);
	}

	/**
	 * 以特殊符号格式化字符串 例：3,4,,5,6, 格式化为 3,4,5,6
	 * 
	 * @param str
	 * @param splitStr
	 * @return
	 */
	public static String formatStr(String str, String splitStr) {
		StringBuffer res = new StringBuffer("");
		String[] arr = split(str, splitStr);
		for (int i = 0; i < arr.length; i++) {
			if (checkNull(arr[i])) {
				res.append(arr[i]);
				if (i < arr.length - 1) {
					res.append(",");
				}
			}
		}
		return res.toString();
	}

	// 日期类型的工具方法

	/**
	 * 获取系统日期时间 yyyy-MM-dd HH:mm:ss
	 * 
	 * @return
	 */
	public static String getCurrentDateTime() {
		return DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
	}

	/**
	 * 获取系统日期时间 返回 yyyyMMddHHmmsssss
	 * 
	 * @return
	 */
	public static String getCurrentDateTimes() {
		String ct = "";
		ct = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
		return ct;
	}

	/**
	 * 获取系统日期 yyyy-MM-dd
	 * 
	 * @return
	 */
	public static String getCurrentDate() {
		return DateFormatUtils.format(new Date(), "yyyy-MM-dd");
	}

	/**
	 * 获取系统时间 HH:mm:ss
	 * 
	 * @return
	 */
	public static String getCurrentTime() {
		return DateFormatUtils.format(new Date(), "HH:mm:ss");
	}

	/**
	 * 将短时间格式字符串转换为时间 yyyy-MM-dd
	 * 
	 * @param strDate
	 * @return
	 */
	public static Date strToDate(String strDate) {
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
		ParsePosition pos = new ParsePosition(0);
		Date strtodate = formatter.parse(strDate, pos);
		return strtodate;
	}

	/**
	 * 根据一个日期，返回是星期几的字符串
	 * 
	 * @param sdate
	 * @return
	 */
	public static String getWeek(String sdate) {
		String str = "";
		// 再转换为时间
		Date date = strToDate(sdate);
		Calendar c = Calendar.getInstance();
		c.setTime(date);
		int hour = c.get(Calendar.DAY_OF_WEEK);
		if (1 == hour) {
			str = "07";
		} else if (2 == hour) {
			str = "01";
		} else if (3 == hour) {
			str = "02";
		} else if (4 == hour) {
			str = "03";
		} else if (5 == hour) {
			str = "04";
		} else if (6 == hour) {
			str = "05";
		} else if (7 == hour) {
			str = "06";
		}
		// hour中存的就是星期几了，其范围 1~7
		// 1=星期日 7=星期六，其他类推
		return str;
	}

	/**
	 * 字符串转日期格式
	 * 
	 * @param strDate
	 * @return
	 */
	public static Date formatStrToDate(Object oDate) {
		try {
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			if (null == oDate) {
				return null;
			}
			date = sdf.parse(oDate.toString());
			return date;

		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 字符串转日期格式
	 * 
	 * @param strDate
	 * @return
	 */
	public static Date formatStrToDateYmd(Object oDate) {
		try {
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			if (null == oDate) {
				return null;
			}
			date = sdf.parse(oDate.toString());
			return date;

		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 字符串转日期格式
	 * 
	 * @param strDate
	 * 
	 * @param dateFormat
	 *            日期需要转换的格式(如："yyyy-MM-dd")
	 * 
	 * @return
	 */
	public static Date formatStrToDate(Object oDate, String dateFormat) {
		try {
			Date date = new Date();
			SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
			if (null == oDate) {
				return null;
			}
			date = sdf.parse(oDate.toString());
			return date;

		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 将日期类型转换成字符类型
	 * 
	 * @param date
	 * @return
	 */
	public static String formatDateToStr(Date date) {
		try {
			String dateStr = "";
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			if (null == date) {
				return null;
			}
			dateStr = sdf.format(date);
			return dateStr;
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 将日期类型转换成指定格式字符类型
	 * 
	 * @param date
	 * @return
	 */
	public static String formatDateToStr(Date date, String dateFormat) {
		try {
			String dateStr = "";
			SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
			if (null == date) {
				return null;
			}
			dateStr = sdf.format(date);
			return dateStr;
		} catch (Exception e) {
			return null;
		}
	}

	/**
	 * 获取系统日期时间 根据入参的格式化字符串生成系统日期时间
	 * 
	 * @param dateFormat
	 *            可以是yyyy-MM-dd HH:mm:ss SSS的任意组合
	 * @return
	 */
	public static String getCurrentDateTimeExt(String dateFormat) {
		return DateFormatUtils.format(new Date(), dateFormat);
	}


	/**
	 * 获取天
	 * 
	 * @return
	 * @throws BpmException
	 */
	public static String getDate() {
		String dStr = "";
		Calendar calendar = Calendar.getInstance();
		int date = calendar.get(Calendar.DATE);
		if (date < 10) {
			dStr = "0" + date;
		} else
			dStr = String.valueOf(date);
		return dStr;
	}

	/**
	 * 比较两个时间之间相隔的小时数
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static long getBetweenToDate(String date1, String date2) {
		long hours = 0;
		Date startDate = formatStrToDate(date1);
		Date endDate = formatStrToDate(date2);
		long intervalTimes = endDate.getTime() - startDate.getTime();
		hours = intervalTimes / 1000 / 60 / 60;
		return hours;
	}

	/**
	 * 比较两个日期相隔的天数
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static long getBetweenDays(String date1, String date2) {
		long hours = 0;
		Date startDate = formatStrToDate(date1, "yyyy-MM-dd");
		Date endDate = formatStrToDate(date2, "yyyy-MM-dd");
		long intervalTimes = endDate.getTime() - startDate.getTime();
		hours = intervalTimes / 1000 / 60 / 60 / 24;
		return hours;
	}

	/**
	 * 比较两个时间之间相隔的分钟
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static long getBetweenToMin(String date1, String date2) {
		long min = 0;
		Date startDate = formatStrToDate(date1);
		Date endDate = formatStrToDate(date2);
		long intervalTimes = endDate.getTime() - startDate.getTime();
		min = intervalTimes / 1000;
		return min;
	}

	/**
	 * 比较两个时间之间相隔的分钟
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static long getBetweenToFen(String date1, String date2) {
		long min = 0;
		Date startDate = formatStrToDate(date1);
		Date endDate = formatStrToDate(date2);
		long intervalTimes = endDate.getTime() - startDate.getTime();
		min = intervalTimes / 1000 / 60;
		return min;
	}

	/**
	 * 比较两个时间之间相隔的分钟
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static long getBetweenToFen(String date) {
		long min = 0;
		Date startDate = formatStrToDate(date);
		Date endDate = new Date();
		long intervalTimes = endDate.getTime() - startDate.getTime();
		min = intervalTimes / 1000 / 60;
		return min;
	}

	/**
	 * 比较两个时间之间相隔的miao
	 * 
	 * @param date1
	 * @return
	 */
	public static long getBetweenToMiao(String date1) {
		Date startDate = formatStrToDate(date1);
		Date endDate = new Date();
		;
		long intervalTimes = endDate.getTime() - startDate.getTime();
		return intervalTimes / 1000;
	}

	// 数组类型的工具方法

	/**
	 * 查看数组中元素第一次出现的位置，从0开始，返回-1则不存在。 数组中区分大小写
	 * 
	 * @param obj
	 * @param o
	 * @return
	 */
	public static int arrayIndexOf(Object[] obj, Object o) {
		return ArrayUtils.indexOf(obj, o);
	}

	/**
	 * 查看数组中元素最后一次出现的位置，从0开始，返回-1则不存在。 数组中区分大小写
	 * 
	 * @param obj
	 * @param o
	 * @return
	 */
	public static int arrayLastIndexOf(Object[] obj, Object o) {
		return ArrayUtils.lastIndexOf(obj, o);
	}

	/**
	 * 反转数组 {0,1,2,3,4,5} to {5,4,3,2,1,0}
	 * 
	 * @param obj
	 * @return
	 */
	public static Object[] arrayReverse(Object[] obj) {
		ArrayUtils.reverse(obj);
		return obj;
	}

	/**
	 * 处理字符串
	 * 
	 * @param obj
	 * @return
	 */
	public static String getStr(Object obj) {
		String str = "";
		if (obj != null && !"".equals(obj)) {
			str = obj.toString().trim();
		}
		return str;
	}

	/**
	 * 从String中取得Long
	 * 
	 * @param str
	 *            String参数
	 * @return Long
	 */
	public static long getLong(Object obj) {
		long lnNumber = 0;
		try {

			lnNumber = Long.parseLong(getStr(obj));
		} catch (Exception e) {
		}
		return lnNumber;
	}

	/**
	 * 把String转换为double
	 * 
	 * @param obj
	 * @return
	 */
	public static double getDouble(Object obj) {
		double d = 0;
		try {
			d = Double.parseDouble("" + obj);
		} catch (Exception e) {
		}
		return d;
	}

	/**
	 * 格式化double
	 * 
	 * @param obj
	 * @return
	 */
	public static double getDoubleFormatDouble(double obj) {
		DecimalFormat df = new DecimalFormat("######0.00");
		return new Double(df.format(obj).toString());
	}

	public static String getDoubleFormat(double account) {
		DecimalFormat df = new DecimalFormat("######0.00");
		return df.format(account);
	}

	/**
	 * 从String中取得integer
	 * 
	 * @param str
	 *            String参数
	 * @return Long
	 */
	public static int getInteger(Object obj) {
		int lnNumber = 0;
		try {

			lnNumber = Integer.parseInt(getStr(obj));
		} catch (Exception e) {
		}
		return lnNumber;
	}

	public static int getInt(Object obj) {
		int lnNumber = -1;
		try {

			lnNumber = Integer.parseInt(getStr(obj));
		} catch (Exception e) {
		}
		return lnNumber;
	}

	/**
	 * 字符串非空判断
	 * 
	 * @param str
	 * 
	 * @return boolean true:不为空; false：空
	 * 
	 * @throws FMPException
	 */
	public static boolean checkNull(Object str) {
		boolean falg = false;
		if (null != str && !"".equals(str.toString().trim())) {
			falg = true;
		}
		return falg;
	}

	/**
	 * 判断list中是否存在某个值
	 * 
	 * @param list
	 * @param key
	 * @param value
	 * @return
	 */
	public static boolean isExistInsideList(List<Map<String, Object>> list,
			String key, String value) {
		boolean res = false;
		for (Map<String, Object> map : list) {
			if (Utils.checkNull(map.get(key))) {
				if (map.get(key).toString().equals(value)) {
					res = true;
					break;
				}
			}
		}
		return res;
	}

	/**
	 * 获得系统日期
	 * 
	 * @param timeFormat
	 *            插入想要的格式 如 "yyyy-MM-dd hh:mm:ss" "yyyy-MM-dd"
	 * @return Date 的变量
	 */
	public static Date getSysDate(String timeFormat) {

		Date date = new Date();

		SimpleDateFormat sdf = new SimpleDateFormat(timeFormat);

		String strdate = sdf.format(date);

		Date date1 = null;
		try {
			date1 = sdf.parse(strdate);
		} catch (ParseException e1) {
			e1.printStackTrace();
		}
		return date1;
	}

	/**
	 * 清除字符串中所包含的标签,样式,替换中文标点符号
	 * 
	 * @author xueyuan
	 * @param content
	 * @return
	 */
	public static String clearContentLabel(String content) {
		String regEx_html = "<[^>]+>";
		Pattern p_html = Pattern.compile(regEx_html, Pattern.CASE_INSENSITIVE);
		Matcher m_html = p_html.matcher(content);
		String value = m_html.replaceAll("").replace("&nbsp;", "")
				.replace("）", ")").replace("。", ".").replace("，", ",")
				.replace("？", "?").replace("！", "!").replace("（", "(")
				.replace("（", "(").replace("：", ":");
		return value;
	}

	/**
	 * 根据传入的字符串，返回数字
	 * 
	 * @param str
	 * @return
	 */
	public static String obtainNumberByString(String str) {
		String number = "";
		if (null != str && str != "") {
			String regEx = "[^0-9]";
			Pattern p = Pattern.compile(regEx);
			Matcher m = p.matcher(str);
			number = m.replaceAll("").trim();
		}
		return number;
	}

	public static Date parseDate(String str, String pattern, Locale locale) {
		if (str == null || pattern == null) {
			return null;
		}
		try {
			return new SimpleDateFormat(pattern, locale).parse(str);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	public static long parseString2Long(String time) throws ParseException {
		// 先把字符串转成Date类型
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		// 此处会抛异常
		Date date = sdf.parse(time);
		// 获取毫秒数
		long longDate = date.getTime();
		return longDate;
	}

	public static long parseString2Long(String time, String format)
			throws ParseException {
		// 先把字符串转成Date类型
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		// 此处会抛异常
		Date date = sdf.parse(time);
		// 获取毫秒数
		long longDate = date.getTime();
		return longDate;
	}

	public static String dateFormatStr(Date date, String pattern, Locale locale) {
		if (date == null || pattern == null) {
			return null;
		}
		return new SimpleDateFormat(pattern, locale).format(date);
	}

	/**
	 * 如果上传临时文件夹不存在 创建上传临时文件件
	 * 
	 * @author xueyuan
	 * @param request
	 * @return 返回临时文件夹路径
	 */
	public static String createUploadTempFolder(HttpServletRequest request) {
		StringBuilder path = new StringBuilder(request.getSession()
				.getServletContext().getRealPath("/")).append(File.separator)
				.append(Constants.SAVE_FOLDER);
		StringBuffer tempSavePath = new StringBuffer().append(path)
				.append(File.separator)
				.append(Constants.TEMP_SECOND_SAVE_FOLDER)
				.append(File.separator);
		File tempFile = new File(tempSavePath.toString());
		if (!tempFile.exists()) { // 如果不存在
			tempFile.mkdirs(); // 创建文件
		}
		return tempSavePath.toString();
	}

	public static boolean checkFileFormat(String fileType, String fileName) {
		// 定义允许上传的文件扩展名
		HashMap<String, String> extMap = new HashMap<String, String>();
		extMap.put("image", "gif,jpg,jpeg,png,bmp");
		extMap.put("flash", "swf,flv");
		extMap.put("media", "swf,flv,mp3,wav,wma,wmv,mid,avi,mpg,asf,rm,rmvb");
		extMap.put("file", "apk,pkg");
		extMap.put("certificate", "p12");
		extMap.put("fileExcel", "xls");
		// extMap.put("file",
		// "doc,docx,xls,xlsx,ppt,htm,html,txt,zip,rar,gz,bz2,cad,apk");
		// 扩展名
		String fileExt = fileName.substring(fileName.lastIndexOf(".") + 1)
				.toLowerCase();
		if (!Arrays.<String> asList(extMap.get(fileType).split(",")).contains(
				fileExt)) {
			return false;
		}
		return true;

	}

	/**
	 * 读写文件
	 * 
	 * @author xueyuan
	 * @param path
	 * @param os
	 */
	public static void writeFile(String modularName, String fileName,
			HttpServletRequest request, OutputStream os) {
		StringBuffer path = new StringBuffer();
		if ("huanxiong".equals(modularName)) {
			StringBuilder sb = new StringBuilder(request.getSession()
					.getServletContext().getRealPath("/")).append(
					File.separator).append(Constants.SAVE_FOLDER);
			int index = sb.indexOf("webapps");
			if (index > 0) {
				path.append(sb.substring(0, index)).append("/")
						.append(modularName).append("/").append(fileName);
			}
		} else {
			path.append(Constants.UPLOAD_ROOT_DIRECTORY).append("/")
					.append(modularName).append("/").append(fileName);
		}
		File targetFile = new File(path.toString());
		if (!targetFile.exists()) { // 如果不存在
			return;
		}
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(path.toString());
			int count = 0;
			byte[] buffer = new byte[1024 * 1024];
			while ((count = fis.read(buffer)) != -1)
				os.write(buffer, 0, count);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (os != null) {
					os.close();
				}
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 读写文件
	 * 
	 * @author xueyuan
	 * @param path
	 * @param os
	 */
	public static void writeFile(File file, OutputStream os) {

		FileInputStream fis = null;
		try {
			fis = new FileInputStream(file);
			int count = 0;
			byte[] buffer = new byte[1024 * 1024];
			while ((count = fis.read(buffer)) != -1)
				os.write(buffer, 0, count);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (os != null) {
					os.close();
				}
				if (fis != null) {
					fis.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 创建指定数量的随机数字
	 * 
	 * @param length
	 * @return
	 */
	public static String createRandom(int length) {
		String retStr = "";
		// String strTable = "1234567890abcdefghijkmnpqrstuvwxyz";
		String strTable = "1234567890";
		int len = strTable.length();
		boolean bDone = true;
		do {
			retStr = "";
			int count = 0;
			for (int i = 0; i < length; i++) {
				double dblR = Math.random() * len;
				int intR = (int) Math.floor(dblR);
				char c = strTable.charAt(intR);
				if (('0' <= c) && (c <= '9')) {
					count++;
				}
				retStr += strTable.charAt(intR);
			}
			if (count >= 2) {
				bDone = false;
			}
		} while (bDone);

		return retStr;
	}

	/**
	 * 判断手机格式是否正确
	 * 
	 * @param mobiles
	 * @return
	 */
	public static boolean isMobileNO(String mobiles) {
		// Pattern p = Pattern
		// .compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");
		// Matcher m = p.matcher(mobiles);
		// return m.matches();

		if (mobiles.startsWith("1") && mobiles.length() == 11) {
			return true;
		}
		return false;
	}

	public static String getFormatMacAddress(String macAddress) {
		if (checkNull(macAddress)) {
			String formatAddress = macAddress.substring(5, macAddress.length());
			return formatAddress;
		}
		return null;
	}

	/**
	 * 比较两个日期相隔的天数
	 * 
	 * @param date1
	 * @param date2
	 * @return
	 */
	public static long getBetweenDays(String date1, String date2, String time) {
		long hours = 0;
		Date startDate = formatStrToDate(date1, "HH:mm");
		Date endDate = formatStrToDate(date2, "HH:mm");
		long intervalTimes = endDate.getTime() - startDate.getTime();
		hours = intervalTimes / 1000 / 60 / 60 / 24;
		return hours;
	}

	/**
	 * 获得一个UUID
	 * 
	 * @return String UUID
	 */
	public static String getUUID() {
		String uuid = UUID.randomUUID().toString();
		// 去掉“-”符号
		return uuid.replaceAll("-", "");
	}

	/**
	 * 获取误差停止时间
	 * 
	 * @param time
	 * @return
	 */
	public static int getBreakTime(int time) {
		int retTime = 0;
		if (time < 10) {
			retTime = 1;
		} else {
			retTime = 2;
		}
		return retTime;
		// int retTime = 0;
		// if (time < 10) {
		// retTime = time / 2;
		// } else {
		// retTime = time / 10 * 2;
		// }
		//
		// if (retTime > 10) {
		// retTime = 9;
		// }
		// if (retTime == 0) {
		// retTime = 1;
		// }
		// return retTime;
	}

	/**
	 * 获取工作时间
	 * 
	 * @param time
	 * @return
	 */
	public static int getWorkTime(int workTime) {
		if (workTime > 1) {
			workTime = workTime - 1;
		} else {
			workTime = 1;
		}
		return workTime;
	}

	// 过滤特殊字符
	public static String stringFilter(String str) throws PatternSyntaxException {
		// 只允许字母和数字
		// String regEx = "[^a-zA-Z0-9]";
		// 清除掉所有特殊字符
		String regEx = "[`~!@#$%^&*()+=|{}':;',\\[\\].<>/?~！@#￥%……&*（）——+|{}【】‘；：”“’。，、？]";
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(str);
		return m.replaceAll("").trim();
	}

	public static String getInitStr() {
		String sdate = formatDateToStr(new Date(), "MMyy");
		String sdd = formatDateToStr(new Date(), "dd");
		String week = getWeek(formatDateToStr(new Date(), "yyyy-MM-dd"));
		String sdates = formatDateToStr(new Date(), "ssmmHH");
		return sdates + sdd + week+ sdate;
	}
	
	public static String initRechargeCheck(String balance) {
		 if(balance.length() == 4){
			String yu = balance.substring(0, 2);
			String er = balance.substring(2, 4);
			int balanceInt = Integer.parseInt(yu, 16) + Integer.parseInt(er, 16);
			String balanceStr = Integer.toHexString(balanceInt);
			int length = balanceStr.length();
			if(length > 2){
				balanceStr = balanceStr.substring(balanceStr.length() -2, balanceStr.length());
			}
			String minute = Integer.toHexString(Utils.getInt(formatDateToStr(new Date(), "mm")));
			return xor(balanceStr, minute);
		 }
		 return "";
	}
	
	private static String xor(String strHex_X,String strHex_Y){
        //将x、y转成二进制形式   
        String anotherBinary=Integer.toBinaryString(Integer.valueOf(strHex_X,16));   
        String thisBinary=Integer.toBinaryString(Integer.valueOf(strHex_Y,16));   
        String result = "";   
        //判断是否为8位二进制，否则左补零   
        if(anotherBinary.length() != 8){   
        for (int i = anotherBinary.length(); i <8; i++) {   
                anotherBinary = "0"+anotherBinary;   
            }   
        }   
        if(thisBinary.length() != 8){   
        for (int i = thisBinary.length(); i <8; i++) {   
                thisBinary = "0"+thisBinary;   
            }   
        }   
        //异或运算   
        for(int i=0;i<anotherBinary.length();i++){   
        //如果相同位置数相同，则补0，否则补1   
                if(thisBinary.charAt(i)==anotherBinary.charAt(i))   
                    result+="0";   
                else{   
                    result+="1";   
                }   
            }  
        return Integer.toHexString(Integer.parseInt(result, 2)).toUpperCase();   
    }
	
	public static void main(String[] args) {
		System.out.println(initRechargeCheck("2710"));
	}
}